#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <stack>

//#define ONLINE_JUDGE

using namespace std;

class Digrafo {
	private:
		int m_nodos;
		vector< list<int> > *m_aristas;
	
	public:
		Digrafo(int n) {
			m_nodos = n;
			m_aristas = new vector< list<int> > (n, list<int> () );
		}
		
		~Digrafo() {
			delete m_aristas;
		}
		
		void ponerArtista(int nodo1, int nodo2) {
			(*m_aristas)[nodo1-1].push_back(nodo2);
		}
		
		int nodos() const {
			return m_nodos;
		}
		
		list<int> adyacencias(int nodo) const {
			return (*m_aristas)[nodo-1];
		}
		
		friend ostream& operator<<(ostream &salida, const Digrafo &g) {
			for(int i = 0; i < g.m_nodos; i++) {
				salida << "* " << i+1 << ": ";
				
				list<int> aristas = (*g.m_aristas)[i];
				for(list<int>::iterator it = aristas.begin(); it != aristas.end(); it++) {
					salida << *it << " ";
				}
				salida << endl;
			}
			return salida;
		}
};

class Eleccion {
private:
	vector< vector<int> > *m_votantes_prioridades;
	int m_votantes, m_candidatos;
	
public:
	Eleccion(int votantes, int candidatos) {
		m_votantes_prioridades = new vector< vector<int> > (votantes, vector<int> (candidatos));
		m_votantes = votantes;
		m_candidatos = candidatos;
	}

	~Eleccion() {
		delete m_votantes_prioridades;
	}
	
	void setPrioridad(int votante, int candidato, int prioridad) {
		if(votante < 1 || votante > m_votantes)
			return;
		
		if(candidato < 1 || candidato > m_candidatos)
			return;
		
		(*m_votantes_prioridades)[votante-1][candidato-1] = prioridad;
	}
	
	int enfrentar(int candidato1, int candidato2) const {
		int resultado = 0;
		
		for(int i = 0; i < m_votantes; i++) {
			if((*m_votantes_prioridades)[i][candidato1-1] < (*m_votantes_prioridades)[i][candidato2-1])
				resultado++;
			else if((*m_votantes_prioridades)[i][candidato1-1] > (*m_votantes_prioridades)[i][candidato2-1])
				resultado--;
		}
		
		return resultado;
	}
	
	friend ostream& operator<<(ostream &salida, const Eleccion &e) {
			for(vector< vector<int> >::iterator it = (*e.m_votantes_prioridades).begin(); it != (*e.m_votantes_prioridades).end(); it++) {
				vector<int> fila = *it;
				
				for(vector<int>::iterator it2 = fila.begin(); it2 != fila.end(); it2++) {
					salida << *it2 << " ";
				}
				salida << endl;
			}
			
			return salida;
		}
};

Eleccion *armarEleccion(int votantes, int candidatos, const vector< vector<int> > &votaciones ) {
	// Armamos las elecciones en base a las prioridades
	// O(n *m)
	Eleccion *eleccion = new Eleccion(votantes, candidatos);
	
	// O(n *m)
	for ( int i = 0; i < votantes; i++ ) {
		for( int j = 0; j < candidatos; j++) {
			eleccion->setPrioridad(i+1, votaciones[i][j], j+1);
		}
	}
	
	return eleccion;
}

Digrafo *armarGrafo(int votantes, int candidatos, const Eleccion &eleccion) {
	Digrafo *grafo = new Digrafo(candidatos);
		
	for ( int i = 0; i < candidatos; i++ ) {
		for( int j = i + 1; j < candidatos; j++) {
			int resultado = eleccion.enfrentar(i+1, j+1);
			
			if(resultado > 0) {
				grafo->ponerArtista(i+1, j+1);
			} else if(resultado < 0) {
				grafo->ponerArtista(j+1, i+1);
			}
		}
	}
	
	return grafo;
}

string recorrerGrafo(const Digrafo &g, int candidato) { 
	int nodos = g.nodos();
	vector<int> visitados(nodos, 0);
	stack<int> nodos_por_recorrer;
	
	visitados[candidato-1] = 1;
	
	list<int> vecinos = g.adyacencias(candidato);
	for(list<int>::iterator it = vecinos.begin(); it != vecinos.end(); it++)
		nodos_por_recorrer.push(*it);
	
	//cerr << candidato << endl;
	
	while(!nodos_por_recorrer.empty()) {
		int nodo = nodos_por_recorrer.top();
		nodos_por_recorrer.pop();
		
		if(visitados[nodo-1])
			continue;
		
		visitados[nodo-1] = 1;

		//cerr << nodo << endl;
			
		list<int> vecinos = g.adyacencias(nodo);
		for(list<int>::iterator it = vecinos.begin(); it != vecinos.end(); it++)
			nodos_por_recorrer.push(*it);
	}

	//cerr << endl << endl;
	
	/*for(vector<int>::iterator it2 = visitados.begin(); it2 != visitados.end(); it2++) {
		cerr << *it2 << " ";
	}*/
	
	bool todos_visitados = true;
	for(int i = 0; i < nodos && todos_visitados; i++)
		todos_visitados &= visitados[i];

	return (todos_visitados ? "yes" : "no");
}

string resolver(int votantes, int candidatos, int candidato_actual, const vector< vector<int> > &votaciones) {
	// Armamos la matriz de prioridades
	Eleccion *eleccion = armarEleccion(votantes, candidatos, votaciones);
	//cerr << *eleccion;
	//cerr << endl;
	
	// Armamos el grafo dirijido a partir de las votaciones
	Digrafo *grafo = armarGrafo(votantes, candidatos, *eleccion);
	//cerr << *grafo;
	//cerr << endl;
	
	// Recorremos el grafo (DFS)
	string resultado = recorrerGrafo(*grafo, candidato_actual);
	
	// Liberamos la memoria
	delete eleccion;
	delete grafo;
	
	
	return resultado;
}

void resolverDesdeEntrada( istream &entrada, ostream &salida ) {
	int candidatos, votantes, candidato_actual;

	while ( entrada.good() ) {
		entrada >> candidatos >> votantes >> candidato_actual;

		if ( !entrada.good() || (candidatos == 0 && votantes == 0 && candidato_actual == 0))
			break;
		
		vector< vector<int> > *votaciones = new vector< vector<int> >(votantes, vector<int> (candidatos));
		
		// Leemos las votaciones desde la entrada.
		for ( int i = 0; i < votantes; i++ ) {
			for( int j = 0; j < candidatos; j++) {
				int candidato;
				entrada >> candidato;
				
				(*votaciones)[i][j] = candidato;
			}
		}
		
		salida <<  resolver(votantes, candidatos, candidato_actual, *votaciones) << endl;
		
		delete votaciones;
	}
}

#ifdef ONLINE_JUDGE
int main() {
	resolverDesdeEntrada( cin, cout );
	return 0;
}
#endif
